home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / BEERSRC.ZIP / WPNPATH.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-20  |  8.1 KB  |  427 lines
  1. #include <stdio.h>
  2. #include <io.h>
  3. #include <sys\stat.h>
  4. #include <fcntl.h>
  5. #include <alloc.h>
  6. #include <string.h>
  7.  
  8.  
  9.  
  10. #include "baller.h"
  11.  
  12.  
  13. #define    MAXX            320
  14. #define    MAXY            220
  15.  
  16.  
  17. int    nshots = 0;
  18. int    shotlen[400];
  19. int    *shot[400];
  20.  
  21. struct shotstrc shothdr[400];
  22.  
  23.  
  24. // Eichhof Lager
  25. void build0(void)
  26. {
  27.    int   i, y;
  28.    int   s;
  29.    int   *ptr;
  30.  
  31.  
  32.    s = nshots++;
  33.    ptr = shot[s] = calloc(80, 4);
  34.    shotlen[s] = 0;
  35.  
  36.    for (i = 0, y = MAXY; y > 0; i+=2, y -= 14) {
  37.       ptr[i] = 0; ptr[i+1] = -14;
  38.       shotlen[s] += 4;
  39.    }
  40.    ptr[i] = SHOTEND; shotlen[s] += 2;
  41.  
  42.    shothdr[s].shotx = 0;
  43.    shothdr[s].shoty = -1;
  44.    shothdr[s].power = 2;
  45.    shothdr[s].sprite = 9;
  46.  
  47. }
  48.  
  49. void build12345(void) // Pokal.
  50. {
  51.    int   i, y;
  52.    int   s;
  53.    int   *ptr;
  54.  
  55.  
  56.    s = nshots++;
  57.    ptr = shot[s] = calloc(80, 4);
  58.    shotlen[s] = 0;
  59.  
  60.    for (i = 0; i < 26; i+=2) {
  61.       ptr[i] = 0; ptr[i+1] = -6;
  62.       shotlen[s] += 4;
  63.    }
  64.    ptr[i++] = SHOTRELEASE; ptr[i++] = 2; shotlen[s] += 4;
  65.    ptr[i++] = SHOTRELEASE; ptr[i++] = 3; shotlen[s] += 4;
  66.    ptr[i++] = SHOTRELEASE; ptr[i++] = 4; shotlen[s] += 4;
  67.    ptr[i++] = SHOTRELEASE; ptr[i++] = 5; shotlen[s] += 4;
  68.    ptr[i++] = SHOTEND; shotlen[s] += 2;
  69.  
  70.    shothdr[s].shotx = 2;
  71.    shothdr[s].shoty = -8;
  72.    shothdr[s].power = 6;
  73.    shothdr[s].sprite = 10;
  74.  
  75.  
  76.    s = nshots++;
  77.    ptr = shot[s] = calloc(80, 4);
  78.    shotlen[s] = 0;
  79.  
  80.    for (i = 0, y = MAXY; y > 0; y-=6, i+=2) {
  81.       ptr[i] = -6; ptr[i+1] = -6;
  82.       shotlen[s] += 4;
  83.    }
  84.    ptr[i++] = SHOTEND; shotlen[s] += 2;
  85.  
  86.    shothdr[s].shotx = -6;
  87.    shothdr[s].shoty = -6;
  88.    shothdr[s].power = 3;
  89.    shothdr[s].sprite = 18;
  90.  
  91.    s = nshots++;
  92.    ptr = shot[s] = calloc(80, 4);
  93.    shotlen[s] = 0;
  94.  
  95.    for (i = 0, y = MAXY; y > 0; y-=6, i+=2) {
  96.       ptr[i] = 6; ptr[i+1] = -6;
  97.       shotlen[s] += 4;
  98.    }
  99.    ptr[i++] = SHOTEND; shotlen[s] += 2;
  100.  
  101.    shothdr[s].shotx = 6;
  102.    shothdr[s].shoty = -6;
  103.    shothdr[s].power = 3;
  104.    shothdr[s].sprite = 19;
  105.  
  106.    s = nshots++;
  107.    ptr = shot[s] = calloc(80, 4);
  108.    shotlen[s] = 0;
  109.  
  110.    for (i = 0, y = MAXY; y > 0; y-=6, i+=2) {
  111.       ptr[i] = 6; ptr[i+1] = 6;
  112.       shotlen[s] += 4;
  113.    }
  114.    ptr[i++] = SHOTEND; shotlen[s] += 2;
  115.  
  116.    shothdr[s].shotx = 6;
  117.    shothdr[s].shoty = 6;
  118.    shothdr[s].power = 3;
  119.    shothdr[s].sprite = 20;
  120.  
  121.    s = nshots++;
  122.    ptr = shot[s] = calloc(80, 4);
  123.    shotlen[s] = 0;
  124.  
  125.    for (i = 0, y = MAXY; y > 0; y-=6, i+=2) {
  126.       ptr[i] = -6; ptr[i+1] = 6;
  127.       shotlen[s] += 4;
  128.    }
  129.    ptr[i++] = SHOTEND; shotlen[s] += 2;
  130.  
  131.    shothdr[s].shotx = -6;
  132.    shothdr[s].shoty = 6;
  133.    shothdr[s].power = 2;
  134.    shothdr[s].sprite = 21;
  135.  
  136. }
  137.  
  138. // Side
  139. void build67(void)
  140. {
  141.    int   i, y;
  142.    int   s;
  143.    int   *ptr;
  144.  
  145.  
  146.    s = nshots++;
  147.    ptr = shot[s] = calloc(80, 4);
  148.    shotlen[s] = 0;
  149.  
  150.    ptr[0] = SHOTRELEASE; ptr[1] = 7; shotlen[s] += 4;
  151.    for (i = 2, y = MAXX; y > 0; i+=2, y -= 10) {
  152.       ptr[i] = -10; ptr[i+1] = 0;
  153.       shotlen[s] += 4;
  154.    }
  155.    ptr[i] = SHOTEND; shotlen[s] += 2;
  156.  
  157.    shothdr[s].shotx = 0;
  158.    shothdr[s].shoty = 0;
  159.    shothdr[s].power = 2;
  160.    shothdr[s].sprite = 17;
  161.  
  162.    s = nshots++;
  163.    ptr = shot[s] = calloc(80, 4);
  164.    shotlen[s] = 0;
  165.  
  166.    for (i = 0, y = MAXX; y > 0; i+=2, y -= 10) {
  167.       ptr[i] = 10; ptr[i+1] = 0;
  168.       shotlen[s] += 4;
  169.    }
  170.    ptr[i] = SHOTEND; shotlen[s] += 2;
  171.  
  172.    shothdr[s].shotx = 16;
  173.    shothdr[s].shoty = 0;
  174.    shothdr[s].power = 2;
  175.    shothdr[s].sprite = 16;
  176.  
  177.  
  178. }
  179.  
  180. //Cannon
  181. void build8(void)
  182. {
  183.    int   i, y;
  184.    int   s;
  185.    int   *ptr;
  186.  
  187.  
  188.    s = nshots++;
  189.    ptr = shot[s] = calloc(80, 4);
  190.    shotlen[s] = 0;
  191.  
  192.    for (i = 0, y = MAXY; y > 0; i+=2, y -= 10) {
  193.       ptr[i] = 0; ptr[i+1] = -10;
  194.       shotlen[s] += 4;
  195.    }
  196.    ptr[i] = SHOTEND; shotlen[s] += 2;
  197.  
  198.    shothdr[s].shotx = 4;
  199.    shothdr[s].shoty = -12;
  200.    shothdr[s].power = 6;
  201.    shothdr[s].sprite = 15;
  202.  
  203. }
  204.  
  205. //Humpe (back shot)
  206. void build9(void)
  207. {
  208.    int   i, y;
  209.    int   s;
  210.    int   *ptr;
  211.  
  212.  
  213.    s = nshots++;
  214.    ptr = shot[s] = calloc(80, 4);
  215.    shotlen[s] = 0;
  216.  
  217.    for (i = 0, y = MAXY; y > 0; i+=2, y -= 10) {
  218.       ptr[i] = 0; ptr[i+1] = 10;
  219.       shotlen[s] += 4;
  220.    }
  221.    ptr[i] = SHOTEND; shotlen[s] += 2;
  222.  
  223.    shothdr[s].shotx = 0;
  224.    shothdr[s].shoty = 8;
  225.    shothdr[s].power = 3;
  226.    shothdr[s].sprite = 14;
  227.  
  228. }
  229.  
  230. // V-shot
  231. void build1011(void)
  232. {
  233.    int   i, y;
  234.    int   s;
  235.    int   *ptr;
  236.  
  237.  
  238.    s = nshots++;
  239.    ptr = shot[s] = calloc(80, 4);
  240.    shotlen[s] = 0;
  241.  
  242.    ptr[0] = SHOTRELEASE; ptr[1] = 11; shotlen[s] += 4;
  243.    for (i = 2, y = MAXY; y > 0; i+=2, y -= 14) {
  244.       ptr[i] = -6; ptr[i+1] = -14;
  245.       shotlen[s] += 4;
  246.    }
  247.    ptr[i] = SHOTEND; shotlen[s] += 2;
  248.  
  249.    shothdr[s].shotx = 2;
  250.    shothdr[s].shoty = -1;
  251.    shothdr[s].power = 2;
  252.    shothdr[s].sprite = 12;
  253.  
  254.    s = nshots++;
  255.    ptr = shot[s] = calloc(80, 4);
  256.    shotlen[s] = 0;
  257.  
  258.    for (i = 0, y = MAXY; y > 0; i+=2, y -= 14) {
  259.       ptr[i] = 6; ptr[i+1] = -14;
  260.       shotlen[s] += 4;
  261.    }
  262.    ptr[i] = SHOTEND; shotlen[s] += 2;
  263.  
  264.    shothdr[s].shotx = 0;
  265.    shothdr[s].shoty = 0;
  266.    shothdr[s].power = 2;
  267.    shothdr[s].sprite = 12;
  268.  
  269.  
  270. }
  271.  
  272.  
  273. //Stange
  274. void build12(void)
  275. {
  276.    int   i, y;
  277.    int   s;
  278.    int   *ptr;
  279.  
  280.  
  281.    s = nshots++;
  282.    ptr = shot[s] = calloc(80, 4);
  283.    shotlen[s] = 0;
  284.  
  285.    for (i = 0, y = MAXY; y > 0; i+=2, y -= 10) {
  286.       ptr[i] = 0; ptr[i+1] = -10;
  287.       shotlen[s] += 4;
  288.    }
  289.    ptr[i] = SHOTEND; shotlen[s] += 2;
  290.  
  291.    shothdr[s].shotx = 0;
  292.    shothdr[s].shoty = -6;
  293.    shothdr[s].power = 3;
  294.    shothdr[s].sprite = 10;
  295.  
  296. }
  297.  
  298.  
  299. //Homing
  300. void build13(void)
  301. {
  302.    int   i, y;
  303.    int   s;
  304.    int   *ptr;
  305.  
  306.  
  307.    s = nshots++;
  308.    ptr = shot[s] = calloc(80, 4);
  309.    shotlen[s] = 0;
  310.    ptr[0] = 0; ptr[1] = -12; shotlen[s] += 4;
  311.    for (i = 2; i < 40; i+=2) {
  312.       ptr[i] = SHOTHOMING; ptr[i+1] = SHOTHOMING;
  313.       shotlen[s] += 4;
  314.    }
  315.    ptr[i] = SHOTEND; shotlen[s] += 2;
  316.  
  317.    shothdr[s].shotx = 2;
  318.    shothdr[s].shoty = -1;
  319.    shothdr[s].power = 2;
  320.    shothdr[s].speed = 12;
  321.    shothdr[s].sprite = 11;
  322.  
  323. }
  324.  
  325.  
  326. //Pony Reflector
  327. void build1415(void)
  328. {
  329.    int   i, y;
  330.    int   s;
  331.    int   *ptr;
  332.  
  333.  
  334.    s = nshots++;
  335.    ptr = shot[s] = calloc(80, 4);
  336.    shotlen[s] = 0;
  337.  
  338.    ptr[0] = SHOTRELEASE; ptr[1] = 15; shotlen[s] += 4;
  339.    ptr[2] = -6; ptr[3] = -14; shotlen[s] += 4;
  340.    for (i = 4; i < 32; i+=2) {
  341.       ptr[i] = SHOTREFLECT; ptr[i+1] = SHOTREFLECT;
  342.       shotlen[s] += 4;
  343.    }
  344.    ptr[i] = SHOTEND; shotlen[s] += 2;
  345.  
  346.    shothdr[s].shotx = 2;
  347.    shothdr[s].shoty = -1;
  348.    shothdr[s].power = 2;
  349.    shothdr[s].sprite = 13;
  350.  
  351.    s = nshots++;
  352.    ptr = shot[s] = calloc(80, 4);
  353.    shotlen[s] = 0;
  354.  
  355.    ptr[0] = 6; ptr[1] = -14; shotlen[s] += 4;
  356.    for (i = 2; i < 30; i+=2) {
  357.       ptr[i] = SHOTREFLECT; ptr[i+1] = SHOTREFLECT;
  358.       shotlen[s] += 4;
  359.    }
  360.    ptr[i] = SHOTEND; shotlen[s] += 2;
  361.  
  362.    shothdr[s].shotx = 0;
  363.    shothdr[s].shoty = 0;
  364.    shothdr[s].power = 2;
  365.    shothdr[s].sprite = 13;
  366.  
  367. }
  368.  
  369.  
  370. int savepathes(char *file)
  371. {
  372.    char      fname[80];
  373.    int       filvar, i;
  374.    long      ptr, ptr0;
  375.    long      fptr1, fptr2;
  376.    unsigned  size;
  377.  
  378.  
  379.    strcpy(fname, file);
  380.    filvar = open(strcat(fname, ".SHT"), O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, S_IWRITE);
  381.    if (filvar == -1) return -1;
  382.  
  383.    write(filvar, &nshots, 2);
  384.    fptr1 = tell(filvar);
  385.    ptr = nshots*4;
  386.    write(filvar, shot, ptr);
  387.  
  388.    for (i = 0; i < nshots; i++) {
  389.       write(filvar, &shothdr[i], sizeof(struct shotstrc));
  390.       write(filvar, shot[i], shotlen[i]);
  391.       fptr2 = tell(filvar);
  392.       lseek(filvar, fptr1, SEEK_SET);
  393.       ptr0 = (ptr & 0xf) + ((ptr & 0xffff0) << 12);
  394.       write(filvar, &ptr0, 4);
  395.       ptr += shotlen[i] + sizeof(struct shotstrc);
  396.       fptr1 = tell(filvar);
  397.       lseek(filvar, fptr2, SEEK_SET);
  398.  
  399.    }
  400.    close(filvar);
  401.  
  402.    return 0;
  403.  
  404. }
  405.  
  406.  
  407. void main(void)
  408. {
  409.  
  410.    clrscr();
  411.    printf("\nALPHA-HELIX Shot Path Builder Ver 0.01\n\n");
  412.  
  413.    build0();
  414.    build12345();
  415.    build67();
  416.    build8();
  417.    build9();
  418.    build1011();
  419.    build12();
  420.    build13();
  421.    build1415();
  422.  
  423.    savepathes("weapons");
  424.    printf("Done.\n");
  425.  
  426. }
  427.